package edu.qd.learn.newchapter.chapter04.learncollection;

import java.util.*;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 同级别
 * <p>
 *               集合(特定数据结构完成类)
 *              collection（散列结构）  Iterable 接口 Iterator()           map
 *      List    set   Queue                                          HashMap
 *  (实现类)ArrayList
 * @author 布衣
 */
public class LearnMap {

    public void learnMap(){
        Map<String, String> map = new HashMap<>(4);

        System.out.println(map.size());

        String orDefault = map.getOrDefault("name", "王五");
//        map.put("name", "张三");
        map.put("age", "18");
        map.put("gender", "男");
        map.putIfAbsent("name", "王五");
//        compute 如果desc不存在，添加这组数据
//        map.compute("desc", (k, v) -> v + 1);

//        computeIfPresent 为新值 ,不存在直接null
        map.computeIfPresent("desc", (k,v) -> k);

        //如果 desc 不存在添加，如果desc存在 (k) -> null，表示删除老desc,如果(k) -> "23" ，只做修改
        map.computeIfAbsent("desc", (k) -> k);


//        if(Integer.valueOf(map.get("age")) > 15){
//            map.remove("age");
//        }

//        map.replace("name","张三","王五");
        map.forEach((k, v) -> System.out.printf("key=%s,value=%s\n", k, v));
    }

    public void learnCollection(){
        Collection<String> c = new ArrayList<>();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");
        c.add("e");


        ArrayList<String> c1 = new ArrayList<String>();
        c1.add("1");
        c1.add("2");

        ArrayList<String> clone = (ArrayList<String>)c1.clone();
        System.out.println(clone+"===>");
        c1.add("3");
        System.out.println(c1);
        System.out.println(clone+"===>后");
        //全新的循环方式，迭代器 （散列结构 【 没有下标，没有链式 】）
        Iterator<String> iterator = c.iterator();
        while(iterator.hasNext()){
            String str = iterator.next();
            System.out.println(str);
        }

        //增强型for
        for (String s : c) {
            System.out.println(s);
        }

        //foreach lambda
        c.forEach(x-> System.out.println(x));

        // 函数调用
        c.forEach(System.out::println);
    }

    public static void main(String[] args) {
        List<String> list = new Vector<>();
        List<String> list1 = new ArrayList<>();
        List<String> list2 = new LinkedList<>();
        list2.add("ttt");
        System.out.println(list2.get(0));

        System.out.println(list2.stream().count());

        //队列  : fifo  单端队列 一端插入  一端删除
        Queue<String> queue = new LinkedList<>();

        queue.add("1");
        queue.add("2");
        queue.add("3");
        queue.add("4");
        //peek 返回队首元素，不删除 ,队列为空不删除
        //element 返回队首元素，不删除 ,队列为空返回异常
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());

        //A linear collection that supports element insertion and removal at
        // * both ends  Deque
        //双端队列  ： 队首队尾都可以插入删除
        Deque<String> deque = new LinkedList<>();
        deque.addFirst("a");
        deque.addLast("z");
        deque.addFirst("b");

        deque.add("ttttt");//尾插
        System.out.println(deque);

        BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<>(3);
        try {
            blockingQueue.put("3");
            blockingQueue.put("4");
            blockingQueue.put("5");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        System.out.println(blockingQueue);

        // set
        Set<String> set = new HashSet<>();
        set.add("a");
        set.add("b");
        set.add("a");
        set.add("d");
        set.add("a");
        System.out.println(set);

        // Stream 流 副本(...)
        // stream 开端  (开始)
        // stream 中端  （操作执行）
        // stream 终端  （结束）
        Stream<String> stream = set.stream();
        List<String> a = stream.skip(15).limit(5).collect(Collectors.toList());
        System.out.println(a);

        System.out.println(stream.filter(x -> x.equals("a")).count());


    }

}
